{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "25e0f471",
   "metadata": {},
   "source": [
    "# jupyter notebook的快捷使用"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87b56bf9",
   "metadata": {},
   "source": [
    "jupyter Notebook 有两种键盘输入模式。\n",
    ">即命令模式和编辑模式，这与 [Vim](http://www.vim.org/) 有些类似。在编辑模式下，可以往单元中键入代码或文本，此时单元格被绿色的框线包围，且命令模式下的快捷键不生效。在命令模式下，可以用快捷键命令运行单元格，移动单元格，切换单元格编辑状态等等，此时的单元格被灰色的框线包围，且编辑模式下的快捷键不生效。\n",
    "\n",
    "从命令模式进入编辑模式需按 `Enter` 键，从编辑模式切换到命令模式需按 `Esc` 键。\n",
    "\n",
    "以下两表分别是对命令和编辑两种模式下快捷键的简单说明：\n",
    "\n",
    "## 命令模式快捷键（按 Esc 键开启）:\n",
    "\n",
    "<table><thead>\n",
    "<tr>\n",
    "<th>快捷键</th>\n",
    "<th>作用</th>\n",
    "<th>说明</th>\n",
    "</tr>\n",
    "</thead><tbody>\n",
    "<tr>\n",
    "<td>Enter</td>\n",
    "<td>转入编辑模式</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-Enter</td>\n",
    "<td>运行本单元，选中下个单元</td>\n",
    "<td>新单元默认为命令模式</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Enter</td>\n",
    "<td>运行本单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Alt-Enter</td>\n",
    "<td>运行本单元，在其下插入新单元</td>\n",
    "<td>新单元默认为编辑模式</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Y</td>\n",
    "<td>单元转入代码状态</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>M</td>\n",
    "<td>单元转入 markdown 状态</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>R</td>\n",
    "<td>单元转入 raw 状态</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>1</td>\n",
    "<td>设定 1 级标题</td>\n",
    "<td>仅在 markdown 状态下时建议使用标题相关快捷键，如果单元处于其他状态，则会强制切换到 markdown 状态</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>2</td>\n",
    "<td>设定 2 级标题</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>3</td>\n",
    "<td>设定 3 级标题</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>4</td>\n",
    "<td>设定 4 级标题</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>5</td>\n",
    "<td>设定 5 级标题</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>6</td>\n",
    "<td>设定 6 级标题</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Up</td>\n",
    "<td>选中上方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>K</td>\n",
    "<td>选中上方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Down</td>\n",
    "<td>选中下方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>J</td>\n",
    "<td>选中下方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-K</td>\n",
    "<td>连续选择上方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-J</td>\n",
    "<td>连续选择下方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>A</td>\n",
    "<td>在上方插入新单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>B</td>\n",
    "<td>在下方插入新单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>X</td>\n",
    "<td>剪切选中的单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>C</td>\n",
    "<td>复制选中的单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-V</td>\n",
    "<td>粘贴到上方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>V</td>\n",
    "<td>粘贴到下方单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Z</td>\n",
    "<td>恢复删除的最后一个单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>D,D</td>\n",
    "<td>删除选中的单元</td>\n",
    "<td>连续按两个 D 键</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-M</td>\n",
    "<td>合并选中的单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-S</td>\n",
    "<td>保存当前 NoteBook</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>S</td>\n",
    "<td>保存当前 NoteBook</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>L</td>\n",
    "<td>开关行号</td>\n",
    "<td>编辑框的行号是可以开启和关闭的</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>O</td>\n",
    "<td>转换输出</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-O</td>\n",
    "<td>转换输出滚动</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Esc</td>\n",
    "<td>关闭页面</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Q</td>\n",
    "<td>关闭页面</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>H</td>\n",
    "<td>显示快捷键帮助</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>I,I</td>\n",
    "<td>中断 NoteBook 内核</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>0,0</td>\n",
    "<td>重启 NoteBook 内核</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift</td>\n",
    "<td>忽略</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-Space</td>\n",
    "<td>向上滚动</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Space</td>\n",
    "<td>向下滚动</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "</tbody></table>\n",
    "\n",
    "### 编辑模式快捷键（ 按 Enter 键启动）:\n",
    "\n",
    "<table><thead>\n",
    "<tr>\n",
    "<th>快捷键</th>\n",
    "<th>作用</th>\n",
    "<th>说明</th>\n",
    "</tr>\n",
    "</thead><tbody>\n",
    "<tr>\n",
    "<td>Tab</td>\n",
    "<td>代码补全或缩进</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-Tab</td>\n",
    "<td>提示</td>\n",
    "<td>输出帮助信息，部分函数、类、方法等会显示其定义原型，如果在其后加 `?` 再运行会显示更加详细的帮助</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-]</td>\n",
    "<td>缩进</td>\n",
    "<td>向右缩进</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-[</td>\n",
    "<td>解除缩进</td>\n",
    "<td>向左缩进</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-A</td>\n",
    "<td>全选</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Z</td>\n",
    "<td>撤销</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Shift-Z</td>\n",
    "<td>重做</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Y</td>\n",
    "<td>重做</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Home</td>\n",
    "<td>跳到单元开头</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Up</td>\n",
    "<td>跳到单元开头</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-End</td>\n",
    "<td>跳到单元末尾</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Down</td>\n",
    "<td>跳到单元末尾</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Left</td>\n",
    "<td>跳到左边一个字首</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Right</td>\n",
    "<td>跳到右边一个字首</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Backspace</td>\n",
    "<td>删除前面一个字</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Delete</td>\n",
    "<td>删除后面一个字</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Esc</td>\n",
    "<td>切换到命令模式</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-M</td>\n",
    "<td>切换到命令模式</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift-Enter</td>\n",
    "<td>运行本单元，选中下一单元</td>\n",
    "<td>新单元默认为命令模式</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Enter</td>\n",
    "<td>运行本单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Alt-Enter</td>\n",
    "<td>运行本单元，在下面插入一单元</td>\n",
    "<td>新单元默认为编辑模式</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Shift--</td>\n",
    "<td>分割单元</td>\n",
    "<td>按光标所在行进行分割</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-Shift-Subtract</td>\n",
    "<td>分割单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-S</td>\n",
    "<td>保存当前 NoteBook</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Shift</td>\n",
    "<td>忽略</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Up</td>\n",
    "<td>光标上移或转入上一单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Down</td>\n",
    "<td>光标下移或转入下一单元</td>\n",
    "<td></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Ctrl-/</td>\n",
    "<td>注释整行/撤销注释</td>\n",
    "<td>仅代码状态有效</td>\n",
    "</tr>\n",
    "</tbody></table>\n",
    "\n",
    "**注：** 如果快捷键被系统中的其它应用占用，则可能会失效"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9031356",
   "metadata": {},
   "source": [
    "## 模块的拓展\n",
    ">1.range() 函数用法  \n",
    ">2.Python random() 函数  \n",
    ">3.enumerate的介绍"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4e028eb",
   "metadata": {},
   "source": [
    "### 函数语法\n",
    "```\n",
    "range(stop)\n",
    "range(start, stop[, step])\n",
    "```\n",
    "- start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;  \n",
    "- stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5  \n",
    "- step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7fd74633",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ae1b3c05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e55b51a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class range in module builtins:\n",
      "\n",
      "class range(object)\n",
      " |  range(stop) -> range object\n",
      " |  range(start, stop[, step]) -> range object\n",
      " |  \n",
      " |  Return an object that produces a sequence of integers from start (inclusive)\n",
      " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      " |  These are exactly the valid indices for a list of 4 elements.\n",
      " |  When step is given, it specifies the increment (or decrement).\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Return a reverse iterator.\n",
      " |  \n",
      " |  count(...)\n",
      " |      rangeobject.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      rangeobject.index(value) -> integer -- return index of value.\n",
      " |      Raise ValueError if the value is not present.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  start\n",
      " |  \n",
      " |  step\n",
      " |  \n",
      " |  stop\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "465a0477",
   "metadata": {},
   "source": [
    "### Python random() 函数\n",
    "*描述\n",
    "random() 方法返回随机生成的一个实数，它在[0,1)范围内。*\n",
    "> 以下是 random() 方法的语法:\n",
    "```\n",
    "import random\n",
    "\n",
    "random.random()\n",
    "```\n",
    "注意：random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "07c57f74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "0.21187616363577333\n",
      "4.063176161916225\n",
      "t\n",
      "93\n",
      "[6, 5, 3, 7, 1]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  \n",
    "print( random.random() )             # 产生 0 到 1 之间的随机浮点数\n",
    "print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数\n",
    "print( random.choice('tomorrow') )   # 从序列中随机选取一个元素\n",
    "print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数\n",
    "\n",
    "a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱\n",
    "random.shuffle(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d0d058bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module random:\n",
      "\n",
      "NAME\n",
      "    random - Random variable generators.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.8/library/random\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "        integers\n",
      "        --------\n",
      "               uniform within range\n",
      "    \n",
      "        sequences\n",
      "        ---------\n",
      "               pick random element\n",
      "               pick random sample\n",
      "               pick weighted random sample\n",
      "               generate random permutation\n",
      "    \n",
      "        distributions on the real line:\n",
      "        ------------------------------\n",
      "               uniform\n",
      "               triangular\n",
      "               normal (Gaussian)\n",
      "               lognormal\n",
      "               negative exponential\n",
      "               gamma\n",
      "               beta\n",
      "               pareto\n",
      "               Weibull\n",
      "    \n",
      "        distributions on the circle (angles 0 to 2pi)\n",
      "        ---------------------------------------------\n",
      "               circular uniform\n",
      "               von Mises\n",
      "    \n",
      "    General notes on the underlying Mersenne Twister core generator:\n",
      "    \n",
      "    * The period is 2**19937-1.\n",
      "    * It is one of the most extensively tested generators in existence.\n",
      "    * The random() method is implemented in C, executes in a single Python step,\n",
      "      and is, therefore, threadsafe.\n",
      "\n",
      "CLASSES\n",
      "    _random.Random(builtins.object)\n",
      "        Random\n",
      "            SystemRandom\n",
      "    \n",
      "    class Random(_random.Random)\n",
      "     |  Random(x=None)\n",
      "     |  \n",
      "     |  Random number generator base class used by bound module functions.\n",
      "     |  \n",
      "     |  Used to instantiate instances of Random to get generators that don't\n",
      "     |  share state.\n",
      "     |  \n",
      "     |  Class Random can also be subclassed if you want to use a different basic\n",
      "     |  generator of your own devising: in that case, override the following\n",
      "     |  methods:  random(), seed(), getstate(), and setstate().\n",
      "     |  Optionally, implement a getrandbits() method so that randrange()\n",
      "     |  can cover arbitrarily large ranges.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  getstate(self)\n",
      "     |      Return internal state; can be passed to setstate() later.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  seed(self, a=None, version=2)\n",
      "     |      Initialize internal state from hashable object.\n",
      "     |      \n",
      "     |      None or no argument seeds from current time or from an operating\n",
      "     |      system specific randomness source if available.\n",
      "     |      \n",
      "     |      If *a* is an int, all bits are used.\n",
      "     |      \n",
      "     |      For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "     |      bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "     |      sequences from older versions of Python), the algorithm for str and\n",
      "     |      bytes generates a narrower range of seeds.\n",
      "     |  \n",
      "     |  setstate(self, state)\n",
      "     |      Restore internal state from object returned by getstate().\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods defined here:\n",
      "     |  \n",
      "     |  __init_subclass__(**kwargs) from builtins.type\n",
      "     |      Control how subclasses generate random integers.\n",
      "     |      \n",
      "     |      The algorithm a subclass can use depends on the random() and/or\n",
      "     |      getrandbits() implementation available to it and determines\n",
      "     |      whether it can generate random integers from arbitrarily large\n",
      "     |      ranges.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  getrandbits(self, k, /)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  random(self, /)\n",
      "     |      random() -> x in the interval [0, 1).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class SystemRandom(Random)\n",
      "     |  SystemRandom(x=None)\n",
      "     |  \n",
      "     |  Alternate random number generator using sources provided\n",
      "     |  by the operating system (such as /dev/urandom on Unix or\n",
      "     |  CryptGenRandom on Windows).\n",
      "     |  \n",
      "     |   Not available on all systems (see os.urandom() for details).\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      SystemRandom\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  getrandbits(self, k)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  getstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  random(self)\n",
      "     |      Get the next random number in the range [0.0, 1.0).\n",
      "     |  \n",
      "     |  seed(self, *args, **kwds)\n",
      "     |      Stub method.  Not used for a system random number generator.\n",
      "     |  \n",
      "     |  setstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from Random:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Class methods inherited from Random:\n",
      "     |  \n",
      "     |  __init_subclass__(**kwargs) from builtins.type\n",
      "     |      Control how subclasses generate random integers.\n",
      "     |      \n",
      "     |      The algorithm a subclass can use depends on the random() and/or\n",
      "     |      getrandbits() implementation available to it and determines\n",
      "     |      whether it can generate random integers from arbitrarily large\n",
      "     |      ranges.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from Random:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from Random:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    betavariate(alpha, beta) method of Random instance\n",
      "        Beta distribution.\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        Returned values range between 0 and 1.\n",
      "    \n",
      "    choice(seq) method of Random instance\n",
      "        Choose a random element from a non-empty sequence.\n",
      "    \n",
      "    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance\n",
      "        Return a k sized list of population elements chosen with replacement.\n",
      "        \n",
      "        If the relative weights or cumulative weights are not specified,\n",
      "        the selections are made with equal probability.\n",
      "    \n",
      "    expovariate(lambd) method of Random instance\n",
      "        Exponential distribution.\n",
      "        \n",
      "        lambd is 1.0 divided by the desired mean.  It should be\n",
      "        nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "        a reserved word in Python.)  Returned values range from 0 to\n",
      "        positive infinity if lambd is positive, and from negative\n",
      "        infinity to 0 if lambd is negative.\n",
      "    \n",
      "    gammavariate(alpha, beta) method of Random instance\n",
      "        Gamma distribution.  Not the gamma function!\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        \n",
      "        The probability distribution function is:\n",
      "        \n",
      "                    x ** (alpha - 1) * math.exp(-x / beta)\n",
      "          pdf(x) =  --------------------------------------\n",
      "                      math.gamma(alpha) * beta ** alpha\n",
      "    \n",
      "    gauss(mu, sigma) method of Random instance\n",
      "        Gaussian distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.  This is\n",
      "        slightly faster than the normalvariate() function.\n",
      "        \n",
      "        Not thread-safe without a lock around calls.\n",
      "    \n",
      "    getrandbits(k, /) method of Random instance\n",
      "        getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "    \n",
      "    getstate() method of Random instance\n",
      "        Return internal state; can be passed to setstate() later.\n",
      "    \n",
      "    lognormvariate(mu, sigma) method of Random instance\n",
      "        Log normal distribution.\n",
      "        \n",
      "        If you take the natural logarithm of this distribution, you'll get a\n",
      "        normal distribution with mean mu and standard deviation sigma.\n",
      "        mu can have any value, and sigma must be greater than zero.\n",
      "    \n",
      "    normalvariate(mu, sigma) method of Random instance\n",
      "        Normal distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.\n",
      "    \n",
      "    paretovariate(alpha) method of Random instance\n",
      "        Pareto distribution.  alpha is the shape parameter.\n",
      "    \n",
      "    randint(a, b) method of Random instance\n",
      "        Return random integer in range [a, b], including both end points.\n",
      "    \n",
      "    random() method of Random instance\n",
      "        random() -> x in the interval [0, 1).\n",
      "    \n",
      "    randrange(start, stop=None, step=1, _int=<class 'int'>) method of Random instance\n",
      "        Choose a random item from range(start, stop[, step]).\n",
      "        \n",
      "        This fixes the problem with randint() which includes the\n",
      "        endpoint; in Python this is usually not what you want.\n",
      "    \n",
      "    sample(population, k) method of Random instance\n",
      "        Chooses k unique random elements from a population sequence or set.\n",
      "        \n",
      "        Returns a new list containing elements from the population while\n",
      "        leaving the original population unchanged.  The resulting list is\n",
      "        in selection order so that all sub-slices will also be valid random\n",
      "        samples.  This allows raffle winners (the sample) to be partitioned\n",
      "        into grand prize and second place winners (the subslices).\n",
      "        \n",
      "        Members of the population need not be hashable or unique.  If the\n",
      "        population contains repeats, then each occurrence is a possible\n",
      "        selection in the sample.\n",
      "        \n",
      "        To choose a sample in a range of integers, use range as an argument.\n",
      "        This is especially fast and space efficient for sampling from a\n",
      "        large population:   sample(range(10000000), 60)\n",
      "    \n",
      "    seed(a=None, version=2) method of Random instance\n",
      "        Initialize internal state from hashable object.\n",
      "        \n",
      "        None or no argument seeds from current time or from an operating\n",
      "        system specific randomness source if available.\n",
      "        \n",
      "        If *a* is an int, all bits are used.\n",
      "        \n",
      "        For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "        bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "        sequences from older versions of Python), the algorithm for str and\n",
      "        bytes generates a narrower range of seeds.\n",
      "    \n",
      "    setstate(state) method of Random instance\n",
      "        Restore internal state from object returned by getstate().\n",
      "    \n",
      "    shuffle(x, random=None) method of Random instance\n",
      "        Shuffle list x in place, and return None.\n",
      "        \n",
      "        Optional argument random is a 0-argument function returning a\n",
      "        random float in [0.0, 1.0); if it is the default None, the\n",
      "        standard random.random will be used.\n",
      "    \n",
      "    triangular(low=0.0, high=1.0, mode=None) method of Random instance\n",
      "        Triangular distribution.\n",
      "        \n",
      "        Continuous distribution bounded by given lower and upper limits,\n",
      "        and having a given mode value in-between.\n",
      "        \n",
      "        http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "    \n",
      "    uniform(a, b) method of Random instance\n",
      "        Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "    \n",
      "    vonmisesvariate(mu, kappa) method of Random instance\n",
      "        Circular data distribution.\n",
      "        \n",
      "        mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "        kappa is the concentration parameter, which must be greater than or\n",
      "        equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "        to a uniform random angle over the range 0 to 2*pi.\n",
      "    \n",
      "    weibullvariate(alpha, beta) method of Random instance\n",
      "        Weibull distribution.\n",
      "        \n",
      "        alpha is the scale parameter and beta is the shape parameter.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['Random', 'seed', 'random', 'uniform', 'randint', 'choice',...\n",
      "\n",
      "FILE\n",
      "    d:\\conda\\anaconda\\lib\\random.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(random)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ebdd815",
   "metadata": {},
   "source": [
    "### enumerate的介绍\n",
    "**enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。**\n",
    "> 以下是 enumerate() 方法的语法:\n",
    "```\n",
    "enumerate(sequence, [start=0])\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6cc582e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 one\n",
      "1 two\n",
      "2 three\n"
     ]
    }
   ],
   "source": [
    "# 一个普通的for循环\n",
    "i = 0\n",
    "seq = ['one', 'two', 'three']\n",
    "for element in seq:\n",
    "    print (i, seq[i])\n",
    "    i +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ea151f89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 one\n",
      "1 two\n",
      "2 three\n"
     ]
    }
   ],
   "source": [
    "# 加入enumerate(枚举)自动向下递进\n",
    "seq = ['one', 'two', 'three']\n",
    "for i, element in enumerate(seq):\n",
    "    print (i, element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1706c817",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
